﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace Teigha.Core
{
	public class OdGeCurve2d : OdGeEntity2d
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdGeCurve2d(IntPtr cPtr, bool cMemoryOwn) : base(GlobalsPINVOKE.OdGeCurve2d_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdGeCurve2d obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdGeCurve2d()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							GlobalsPINVOKE.delete_OdGeCurve2d(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		public void getInterval(OdGeInterval interval)
		{
			GlobalsPINVOKE.OdGeCurve2d_getInterval__SWIG_0(this.swigCPtr, OdGeInterval.getCPtr(interval));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getInterval(OdGeInterval interval, OdGePoint2d start, OdGePoint2d end)
		{
			GlobalsPINVOKE.OdGeCurve2d_getInterval__SWIG_1(this.swigCPtr, OdGeInterval.getCPtr(interval), OdGePoint2d.getCPtr(start), OdGePoint2d.getCPtr(end));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeCurve2d reverseParam()
		{
			OdGeCurve2d result = new OdGeCurve2d(GlobalsPINVOKE.OdGeCurve2d_reverseParam(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeCurve2d setInterval()
		{
			OdGeCurve2d result = new OdGeCurve2d(GlobalsPINVOKE.OdGeCurve2d_setInterval__SWIG_0(this.swigCPtr), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool setInterval(OdGeInterval interval)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_setInterval__SWIG_1(this.swigCPtr, OdGeInterval.getCPtr(interval));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double distanceTo(OdGePoint2d point, OdGeTol tol)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_distanceTo__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double distanceTo(OdGePoint2d point)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_distanceTo__SWIG_1(this.swigCPtr, OdGePoint2d.getCPtr(point));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double distanceTo(OdGeCurve2d otherCur, OdGeTol tol)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_distanceTo__SWIG_2(this.swigCPtr, OdGeCurve2d.getCPtr(otherCur), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double distanceTo(OdGeCurve2d otherCur)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_distanceTo__SWIG_3(this.swigCPtr, OdGeCurve2d.getCPtr(otherCur));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGePoint2d closestPointTo(OdGePoint2d point, OdGeTol tol)
		{
			OdGePoint2d result = new OdGePoint2d(GlobalsPINVOKE.OdGeCurve2d_closestPointTo__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGeTol.getCPtr(tol)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGePoint2d closestPointTo(OdGePoint2d point)
		{
			OdGePoint2d result = new OdGePoint2d(GlobalsPINVOKE.OdGeCurve2d_closestPointTo__SWIG_1(this.swigCPtr, OdGePoint2d.getCPtr(point)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGePoint2d closestPointTo(OdGeCurve2d curve2d, OdGePoint2d pntOnOtherCrv, OdGeTol tol)
		{
			OdGePoint2d result = new OdGePoint2d(GlobalsPINVOKE.OdGeCurve2d_closestPointTo__SWIG_2(this.swigCPtr, OdGeCurve2d.getCPtr(curve2d), OdGePoint2d.getCPtr(pntOnOtherCrv), OdGeTol.getCPtr(tol)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGePoint2d closestPointTo(OdGeCurve2d curve2d, OdGePoint2d pntOnOtherCrv)
		{
			OdGePoint2d result = new OdGePoint2d(GlobalsPINVOKE.OdGeCurve2d_closestPointTo__SWIG_3(this.swigCPtr, OdGeCurve2d.getCPtr(curve2d), OdGePoint2d.getCPtr(pntOnOtherCrv)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void getClosestPointTo(OdGePoint2d point, OdGePointOnCurve2d pntOnCrv, OdGeTol tol)
		{
			GlobalsPINVOKE.OdGeCurve2d_getClosestPointTo__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGePointOnCurve2d.getCPtr(pntOnCrv), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getClosestPointTo(OdGePoint2d point, OdGePointOnCurve2d pntOnCrv)
		{
			GlobalsPINVOKE.OdGeCurve2d_getClosestPointTo__SWIG_1(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGePointOnCurve2d.getCPtr(pntOnCrv));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getClosestPointTo(OdGeCurve2d curve2d, OdGePointOnCurve2d pntOnThisCrv, OdGePointOnCurve2d pntOnOtherCrv, OdGeTol tol)
		{
			GlobalsPINVOKE.OdGeCurve2d_getClosestPointTo__SWIG_2(this.swigCPtr, OdGeCurve2d.getCPtr(curve2d), OdGePointOnCurve2d.getCPtr(pntOnThisCrv), OdGePointOnCurve2d.getCPtr(pntOnOtherCrv), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getClosestPointTo(OdGeCurve2d curve2d, OdGePointOnCurve2d pntOnThisCrv, OdGePointOnCurve2d pntOnOtherCrv)
		{
			GlobalsPINVOKE.OdGeCurve2d_getClosestPointTo__SWIG_3(this.swigCPtr, OdGeCurve2d.getCPtr(curve2d), OdGePointOnCurve2d.getCPtr(pntOnThisCrv), OdGePointOnCurve2d.getCPtr(pntOnOtherCrv));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool getNormalPoint(OdGePoint2d point, OdGePointOnCurve2d pntOnCrv, OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_getNormalPoint__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGePointOnCurve2d.getCPtr(pntOnCrv), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool getNormalPoint(OdGePoint2d point, OdGePointOnCurve2d pntOnCrv)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_getNormalPoint__SWIG_1(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGePointOnCurve2d.getCPtr(pntOnCrv));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isOn(OdGePoint2d point, out double param, OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isOn__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(point), out param, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isOn(OdGePoint2d point, out double param)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isOn__SWIG_1(this.swigCPtr, OdGePoint2d.getCPtr(point), out param);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isOn(double param, OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isOn__SWIG_2(this.swigCPtr, param, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isOn(double param)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isOn__SWIG_3(this.swigCPtr, param);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double paramOf(OdGePoint2d point, OdGeTol tol)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_paramOf__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double paramOf(OdGePoint2d point)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_paramOf__SWIG_1(this.swigCPtr, OdGePoint2d.getCPtr(point));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void getTrimmedOffset(double distance, OdGeCurve2dPtrArray offsetCurveList, OdGe.OffsetCrvExtType extensionType, OdGeTol tol)
		{
			GlobalsPINVOKE.OdGeCurve2d_getTrimmedOffset__SWIG_0(this.swigCPtr, distance, OdGeCurve2dPtrArray.getCPtr(offsetCurveList), (int)extensionType, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getTrimmedOffset(double distance, OdGeCurve2dPtrArray offsetCurveList, OdGe.OffsetCrvExtType extensionType)
		{
			GlobalsPINVOKE.OdGeCurve2d_getTrimmedOffset__SWIG_1(this.swigCPtr, distance, OdGeCurve2dPtrArray.getCPtr(offsetCurveList), (int)extensionType);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getTrimmedOffset(double distance, OdGeCurve2dPtrArray offsetCurveList)
		{
			GlobalsPINVOKE.OdGeCurve2d_getTrimmedOffset__SWIG_2(this.swigCPtr, distance, OdGeCurve2dPtrArray.getCPtr(offsetCurveList));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isClosed(OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isClosed__SWIG_0(this.swigCPtr, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isClosed()
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isClosed__SWIG_1(this.swigCPtr);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isPeriodic(out double period)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isPeriodic(this.swigCPtr, out period);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isLinear(OdGeLine2d line, OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isLinear__SWIG_0(this.swigCPtr, OdGeLine2d.getCPtr(line), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isLinear(OdGeLine2d line)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_isLinear__SWIG_1(this.swigCPtr, OdGeLine2d.getCPtr(line));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double length(double fromParam, double toParam, double tol)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_length__SWIG_0(this.swigCPtr, fromParam, toParam, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double length(double tol)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_length__SWIG_1(this.swigCPtr, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double paramAtLength(double datumParam, double length, bool posParamDir, double tol)
		{
			double result = GlobalsPINVOKE.OdGeCurve2d_paramAtLength(this.swigCPtr, datumParam, length, posParamDir, tol);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool area(double startParam, double endParam, out double value, OdGeTol tol)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_area__SWIG_0(this.swigCPtr, startParam, endParam, out value, OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool area(double startParam, double endParam, out double value)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_area__SWIG_1(this.swigCPtr, startParam, endParam, out value);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void getSplitCurves(double param, OdGeCurve2d piece1, OdGeCurve2d piece2)
		{
			GlobalsPINVOKE.OdGeCurve2d_getSplitCurves(this.swigCPtr, param, piece1, piece2);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool explode(OdGeCurve2dPtrArray explodedCurves, OdIntArray newExplodedCurve, OdGeInterval interval)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_explode__SWIG_0(this.swigCPtr, OdGeCurve2dPtrArray.getCPtr(explodedCurves), OdIntArray.getCPtr(newExplodedCurve).Handle, OdGeInterval.getCPtr(interval));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool explode(OdGeCurve2dPtrArray explodedCurves, OdIntArray newExplodedCurve)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_explode__SWIG_1(this.swigCPtr, OdGeCurve2dPtrArray.getCPtr(explodedCurves), OdIntArray.getCPtr(newExplodedCurve).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void getLocalClosestPoints(OdGePoint2d point, OdGePointOnCurve2d approxPnt, OdGeInterval nbhd, OdGeTol tol)
		{
			GlobalsPINVOKE.OdGeCurve2d_getLocalClosestPoints__SWIG_0(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGePointOnCurve2d.getCPtr(approxPnt), OdGeInterval.getCPtr(nbhd), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getLocalClosestPoints(OdGePoint2d point, OdGePointOnCurve2d approxPnt, OdGeInterval nbhd)
		{
			GlobalsPINVOKE.OdGeCurve2d_getLocalClosestPoints__SWIG_1(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGePointOnCurve2d.getCPtr(approxPnt), OdGeInterval.getCPtr(nbhd));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getLocalClosestPoints(OdGePoint2d point, OdGePointOnCurve2d approxPnt)
		{
			GlobalsPINVOKE.OdGeCurve2d_getLocalClosestPoints__SWIG_2(this.swigCPtr, OdGePoint2d.getCPtr(point), OdGePointOnCurve2d.getCPtr(approxPnt));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getLocalClosestPoints(OdGeCurve2d otherCurve, OdGePointOnCurve2d approxPntOnThisCrv, OdGePointOnCurve2d approxPntOnOtherCrv, OdGeInterval nbhd1, OdGeInterval nbhd2, OdGeTol tol)
		{
			GlobalsPINVOKE.OdGeCurve2d_getLocalClosestPoints__SWIG_3(this.swigCPtr, OdGeCurve2d.getCPtr(otherCurve), OdGePointOnCurve2d.getCPtr(approxPntOnThisCrv), OdGePointOnCurve2d.getCPtr(approxPntOnOtherCrv), OdGeInterval.getCPtr(nbhd1), OdGeInterval.getCPtr(nbhd2), OdGeTol.getCPtr(tol));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getLocalClosestPoints(OdGeCurve2d otherCurve, OdGePointOnCurve2d approxPntOnThisCrv, OdGePointOnCurve2d approxPntOnOtherCrv, OdGeInterval nbhd1, OdGeInterval nbhd2)
		{
			GlobalsPINVOKE.OdGeCurve2d_getLocalClosestPoints__SWIG_4(this.swigCPtr, OdGeCurve2d.getCPtr(otherCurve), OdGePointOnCurve2d.getCPtr(approxPntOnThisCrv), OdGePointOnCurve2d.getCPtr(approxPntOnOtherCrv), OdGeInterval.getCPtr(nbhd1), OdGeInterval.getCPtr(nbhd2));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getLocalClosestPoints(OdGeCurve2d otherCurve, OdGePointOnCurve2d approxPntOnThisCrv, OdGePointOnCurve2d approxPntOnOtherCrv, OdGeInterval nbhd1)
		{
			GlobalsPINVOKE.OdGeCurve2d_getLocalClosestPoints__SWIG_5(this.swigCPtr, OdGeCurve2d.getCPtr(otherCurve), OdGePointOnCurve2d.getCPtr(approxPntOnThisCrv), OdGePointOnCurve2d.getCPtr(approxPntOnOtherCrv), OdGeInterval.getCPtr(nbhd1));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getLocalClosestPoints(OdGeCurve2d otherCurve, OdGePointOnCurve2d approxPntOnThisCrv, OdGePointOnCurve2d approxPntOnOtherCrv)
		{
			GlobalsPINVOKE.OdGeCurve2d_getLocalClosestPoints__SWIG_6(this.swigCPtr, OdGeCurve2d.getCPtr(otherCurve), OdGePointOnCurve2d.getCPtr(approxPntOnThisCrv), OdGePointOnCurve2d.getCPtr(approxPntOnOtherCrv));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeBoundBlock2d boundBlock()
		{
			OdGeBoundBlock2d result = new OdGeBoundBlock2d(GlobalsPINVOKE.OdGeCurve2d_boundBlock__SWIG_0(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeBoundBlock2d boundBlock(OdGeInterval range)
		{
			OdGeBoundBlock2d result = new OdGeBoundBlock2d(GlobalsPINVOKE.OdGeCurve2d_boundBlock__SWIG_1(this.swigCPtr, OdGeInterval.getCPtr(range)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeBoundBlock2d orthoBoundBlock()
		{
			OdGeBoundBlock2d result = new OdGeBoundBlock2d(GlobalsPINVOKE.OdGeCurve2d_orthoBoundBlock__SWIG_0(this.swigCPtr), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGeBoundBlock2d orthoBoundBlock(OdGeInterval range)
		{
			OdGeBoundBlock2d result = new OdGeBoundBlock2d(GlobalsPINVOKE.OdGeCurve2d_orthoBoundBlock__SWIG_1(this.swigCPtr, OdGeInterval.getCPtr(range)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool hasStartPoint(OdGePoint2d startPoint)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_hasStartPoint(this.swigCPtr, OdGePoint2d.getCPtr(startPoint));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool hasEndPoint(OdGePoint2d endPoint)
		{
			bool result = GlobalsPINVOKE.OdGeCurve2d_hasEndPoint(this.swigCPtr, OdGePoint2d.getCPtr(endPoint));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGePoint2d evalPoint(double param)
		{
			OdGePoint2d result = new OdGePoint2d(GlobalsPINVOKE.OdGeCurve2d_evalPoint__SWIG_0(this.swigCPtr, param), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdGePoint2d evalPoint(double param, int numDeriv, OdGeVector2dArray derivatives)
		{
			OdGePoint2d result = new OdGePoint2d(GlobalsPINVOKE.OdGeCurve2d_evalPoint__SWIG_1(this.swigCPtr, param, numDeriv, OdGeVector2dArray.getCPtr(derivatives)), true);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void getSamplePoints(double fromParam, double toParam, double approxEps, OdGePoint2dArray pointArray, OdGeDoubleArray paramArray)
		{
			GlobalsPINVOKE.OdGeCurve2d_getSamplePoints__SWIG_0(this.swigCPtr, fromParam, toParam, approxEps, OdGePoint2dArray.getCPtr(pointArray).Handle, OdGeDoubleArray.getCPtr(paramArray));
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getSamplePoints(int numSample, OdGePoint2dArray pointArray)
		{
			GlobalsPINVOKE.OdGeCurve2d_getSamplePoints__SWIG_1(this.swigCPtr, numSample, OdGePoint2dArray.getCPtr(pointArray).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeCurve2d Assign(OdGeCurve2d curve)
		{
			OdGeCurve2d result = new OdGeCurve2d(GlobalsPINVOKE.OdGeCurve2d_Assign(this.swigCPtr, OdGeCurve2d.getCPtr(curve)), false);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void getSamplePoints(double fromParam, double toParam, double approxEps, OdGePoint2dArray pointArray)
		{
			GlobalsPINVOKE.OdGeCurve2d_getSamplePoints__SWIG_3(this.swigCPtr, fromParam, toParam, approxEps, OdGePoint2dArray.getCPtr(pointArray).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void appendSamplePoints(double fromParam, double toParam, double approxEps, OdGePoint2dArray pointArray, OdGeDoubleArray pParamArray)
		{
			GlobalsPINVOKE.OdGeCurve2d_appendSamplePoints__SWIG_0(this.swigCPtr, fromParam, toParam, approxEps, OdGePoint2dArray.getCPtr(pointArray).Handle, OdGeDoubleArray.getCPtr(pParamArray).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void appendSamplePoints(double fromParam, double toParam, double approxEps, OdGePoint2dArray pointArray)
		{
			GlobalsPINVOKE.OdGeCurve2d_appendSamplePoints__SWIG_1(this.swigCPtr, fromParam, toParam, approxEps, OdGePoint2dArray.getCPtr(pointArray).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void appendSamplePoints(int numSample, OdGePoint2dArray pointArray)
		{
			GlobalsPINVOKE.OdGeCurve2d_appendSamplePoints__SWIG_2(this.swigCPtr, numSample, OdGePoint2dArray.getCPtr(pointArray).Handle);
			if (GlobalsPINVOKE.SWIGPendingException.Pending)
			{
				throw GlobalsPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		private object locker = new object();

		private HandleRef swigCPtr;
	}
}
